package v1

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"gin-demo/pkg/setting"
	"gin-demo/pkg/util"
	"github.com/gin-gonic/gin"
	"github.com/go-deepseek/deepseek"
	"github.com/go-deepseek/deepseek/request"
	"io"
)

// 对接 deepseek 的api
var (
	msgFlag4 string // 不知道这个干啥的
)

// 初始化
func init() {
	flag.StringVar(&msgFlag4, "msg4", "", "文本消息")
}

/**
介绍：
role  	   含义
system     表示可以设置机器人的人设
assistant  表示机器人回复内容
user	   表示用户提问问题
*/

type ChatCompletionsRequest4 struct {
	Model    string     `json:"model"`
	Stream   bool       `json:"stream"`
	Messages []*Message `json:"messages"`
}

type Message4 struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type ChatCompletionResponse4 struct {
	ID      string `json:"id"`
	Object  string `json:"object"`
	Created int64  `json:"created"`
	Model   string `json:"model"`
	Choices []struct {
		Delta struct {
			Content string `json:"content"`
		} `json:"delta"`
		Index int `json:"index"`
	} `json:"choices"`
}

// 请求
// 参数介绍具体查看文档：https://api-docs.deepseek.com/zh-cn/

// DeepSeekStreamRequest4 deeepseek 用stream的方式返回
func DeepSeekStreamRequest4(c *gin.Context) {

	// 设置流式响应头
	c.Header("Content-Type", "text/event-stream")
	c.Header("Cache-Control", "no-cache")
	c.Header("Connection", "keep-alive")

	message := c.Query("message") // 是个json
	// systemContent := c.DefaultQuery("system_content", "")

	returnObj := util.NewResponseSuccess()

	msgInput := &MessageInput{}

	errInput := json.Unmarshal([]byte(message), msgInput)
	if errInput != nil {
		returnObj.Code = 422
		returnObj.Msg = "请求参数发生了错误"
		util.ResponseSuccess(c, returnObj)
		return
	}
	if msgInput.Message == "" {
		returnObj.Code = 422
		returnObj.Msg = "message参数不能为空"
		util.ResponseSuccess(c, returnObj)
		return
	}

	// 创建请求体
	client, _ := deepseek.NewClient(setting.DeepSeekConf.API_KEY)

	chatReq := &request.ChatCompletionsRequest{
		Model:  deepseek.DEEPSEEK_CHAT_MODEL,
		Stream: true, // 流式输出
		Messages: []*request.Message{
			{
				Role:    "system",
				Content: msgInput.SystemContent,
			},
			{
				Role:    "user",
				Content: msgInput.Message, // set your input message
			},
		},
	}

	reqJson, _ := json.Marshal(chatReq)
	fmt.Println("发起请求，req=" + string(reqJson))

	//chatResp, err := client.CallChatCompletionsChat(context.Background(), chatReq)
	sr, err := client.StreamChatCompletionsChat(context.Background(), chatReq)
	if err != nil {
		fmt.Println("Error =>", err)
		return
	}

	fmt.Print("output message => ")
	for {
		chatResp, err := sr.Read()
		if err != nil {
			if err == io.EOF {
				break
			}
			panic(err)
		}
		//fmt.Print(chatResp.Choices[0].Delta.Content)
		// 输出流式响应的内容
		for _, choice := range chatResp.Choices {
			jsonData2, err := json.Marshal(choice)
			if err != nil {
				fmt.Println("Error marshalling to JSON:", err)
				return
			}
			// 结束标志：{"finish_reason":"stop","index":0,"message":null,"delta":{"content":"","reasoning_content":""},"logprobs":null}
			if choice.FinishReason == "stop" {
				fmt.Println("message: finish mark")
				c.SSEvent("message", "{\"delta\":{\"content\":\"finish\"},\"index\":0}")
				break
			}

			fmt.Printf("data---: %s\n\n", string(jsonData2)) // 以 SSE 格式输出
			c.SSEvent("message", choice)                     // c.SSEvent 这个是gin框架封装的方法
		}
	}
}
